home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / satellit / pbsv004 / pbdir.c < prev    next >
C/C++ Source or Header  |  1993-08-05  |  7KB  |  316 lines
  1. /* pbdir.c 1993.8.6 */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <search.h>
  7. /* #include <io.h> */
  8. #include <time.h>
  9. /* #include <dos.h> */
  10. #include <assert.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13.  
  14. #include "pbsv.h"
  15.  
  16. extern VOID add_kss(char*,int),add_crc(); /* pbsv.c  */
  17. extern char *dlname(long);
  18. extern VOID initq(),putq();        /* pblib.c */
  19. extern struct stqcell *getq();
  20. extern VOID ca2ad(),ad2ca();
  21. extern int   ckcrc();
  22. extern int calc_crc();            /* crc.c */
  23.  
  24. extern VOID sndkss();            /* pbkiss.c */
  25.  
  26. extern BOOL f_rkss,f_skss;        /* pbsv.c */
  27. extern int lnrkss,lnskss;
  28. extern char rkss[],skss[];
  29. extern struct stqueue actuser;
  30. extern struct stqueue freeuser;
  31. extern struct stqueue freehole;
  32. extern char hdrdqst[];
  33. extern char dldir[];
  34. extern BOOL f_verbose;
  35.  
  36. struct stpfhdir pfhdir[MAXPFHDIR];
  37. int npfhdir;
  38.  
  39. /*
  40.  * < initdir > initialize directory entory
  41.  */
  42. int initdir()
  43. {
  44.     int compare();
  45.     VOID dispdir();
  46.     int pfhstat(char*,struct stpfh *);
  47.  
  48.     char path[128],pathname[128];
  49. typedef    struct find_t buffer;
  50.     struct stat sbuf;
  51.     struct stpfh pfh;
  52.     int i,r;
  53.     long file_id;
  54.  
  55.     sprintf(path,"%s*.DL",dldir);
  56.     printf("Making PFHDIR... %s\n",path);
  57.     for (i = 0; i < MAXPFHDIR ;) {
  58.         if (i == 0) {
  59.             r = _dos_findfirst(path,_A_NORMAL,&buffer);
  60.     } else {
  61.         r = _dos_findnext(&buffer);
  62.     }
  63.     if (r != 0)
  64.         break;
  65.     sscanf(buffer.name,"%lx.DL",&file_id);
  66.     strcpy(pathname,dlname(file_id));
  67.     stat(pathname,&sbuf);
  68.     r = pfhstat(pathname,&pfh);
  69.         printf("\r%d %s",i+1,pathname);
  70.     if (r == 0) {
  71.         pfhdir[i].t_new    = sbuf.st_mtime;
  72.         pfhdir[i].file_id  = file_id;
  73.         pfhdir[i].pfh_size = pfh.pfh_size;
  74.         i++;
  75.     } else {
  76.         printf("...PFH Error!!!\n");
  77.     }
  78.     }
  79.     npfhdir = i;
  80.     printf("\n");
  81.  
  82.     qsort(&pfhdir[0],npfhdir, sizeof(struct stpfhdir),compare);
  83.     pfhdir[0].t_old = 0;
  84.     for (i = 1; i < npfhdir; i++) {
  85.         pfhdir[i].t_old = pfhdir[i-1].t_new + 1;
  86.     }
  87.     if (f_verbose) {
  88.         dispdir();
  89.     }
  90.     return(npfhdir);
  91. }
  92.  
  93. int compare(d1,d2)
  94. struct stpfhdir *d1,*d2;
  95. {
  96.     if (d1->t_new == d2->t_new) {
  97.         return(0);
  98.     } else if ((u_long)d1->t_new > (u_long)d2->t_new) {
  99.         return(1);
  100.     } else {
  101.         return(-1);
  102.     }
  103. }
  104.  
  105. /*
  106.  * < dispdir > display directory
  107.  */
  108. VOID dispdir()
  109. {
  110.     int i;
  111.  
  112.     for (i = 0; i < npfhdir; i++) {
  113.         printf(" %4d %lu,%lu %lX %d\n", i,
  114.             pfhdir[i].t_old,pfhdir[i].t_new,pfhdir[i].file_id,
  115.             pfhdir[i].pfh_size);
  116.     }
  117. }
  118.  
  119. /*
  120.  * < qst_dir > directory
  121.  */
  122. VOID qst_dir(user)
  123. struct stuser *user;
  124. {
  125.     u_char send_pfh();
  126.  
  127.     struct sthole *hole;
  128.     u_char flags;
  129.     int i,j,dirent;
  130.  
  131.     for (i = 0; i < 5; i++) {
  132.         hole = (struct sthole *)user->hole.head;
  133.     if (hole == NULL)
  134.         break;
  135.  
  136.     printf("Dir Start: %ld, End: %lu\n",hole->start,hole->end);
  137.  
  138.         dirent = npfhdir-1;
  139.     for (j = 0; j < npfhdir; j++) {
  140.         if ((u_long)hole->start >= (u_long)pfhdir[j].t_old &&
  141.             (u_long)hole->start <= (u_long)pfhdir[j].t_new) {
  142.         dirent = j;
  143.         break;
  144.         }
  145.     }
  146.     flags = send_pfh(dirent,user->block_size);
  147.     hole->start = pfhdir[dirent].t_new + 1;
  148.  
  149.     if ((u_long)hole->start > (u_long)hole->end || 
  150.                     (flags & 0x40)) { /* hole delete ? */
  151.         hole = (struct sthole *)getq(&user->hole);
  152.         putq(&freehole,hole);
  153.     }
  154.     }
  155. }
  156.  
  157. /*
  158.  * < send_pfh > send PFH
  159.  */
  160. u_char send_pfh(dirent,block_size)
  161. int dirent;
  162. int block_size;
  163. {
  164.     FILE *fp;
  165.     char buf[256];
  166.     u_char flags;
  167.     int size;
  168.     long file_id,offset;
  169.  
  170.     file_id = pfhdir[dirent].file_id;
  171.     if ((fp = fopen(dlname(file_id),"rb")) == NULL) {
  172.         assert(0);
  173.     }
  174.     flags = 0x00;
  175.     if ((dirent+1) == npfhdir)        /* newest file ? */
  176.         flags |= 0x40;
  177.     offset = 0;
  178.     for (;;) {
  179.         size = pfhdir[dirent].pfh_size - offset;
  180.     if (size <= block_size) {
  181.         flags |= 0x20;        /* last byte of frame */
  182.     } else {
  183.         size = block_size;
  184.     }
  185.     printf("QST-1: dir %02x %lx offset=%lu,length=%d\n",
  186.                         flags,file_id,offset,size);
  187. #define SEEK_SET 0
  188.         fseek(fp,offset,SEEK_SET);
  189.         fread(buf,size,1,fp);
  190.     lnskss = 0;
  191.         add_kss(hdrdqst,HDRSIZE);
  192.     add_kss(&flags,1);
  193.     add_kss((char*)&file_id,4);
  194.         add_kss((char*)&offset,4);
  195.     add_kss((char*)&pfhdir[dirent].t_old,4);
  196.     add_kss((char*)&pfhdir[dirent].t_new,4);
  197.         add_kss(buf,size);
  198.     add_crc();
  199.         sndkss();
  200.     if (flags & 0x20) {
  201.         break;
  202.     }
  203.     offset += size;
  204.     }
  205.     fclose(fp);
  206.     return(flags);
  207. }
  208.  
  209. /*
  210.  * < req_dir > request directory
  211.  */
  212. int req_dir(callsign)
  213. char *callsign;
  214. {
  215.     u_char flags;
  216.     u_int  block_size;
  217.     struct stuser *user;
  218.     struct sthole *hole;
  219.     time_t start,end;
  220.     int i;
  221.  
  222.     i = HDRSIZE;
  223.     flags = rkss[i];
  224.     i += 1;
  225.     memcpy(&block_size,&rkss[i],2);
  226.     i += 2;
  227.  
  228.     user = (struct stuser *)getq(&freeuser);
  229.     if (user == NULL) {
  230.     return(-1);        /* queue full */
  231.     }
  232.     user->entry_t = clock();
  233.     user->flags = F_DIR;
  234.     strcpy(user->call,callsign);
  235.     user->block_size = block_size;
  236.     initq(&user->hole);
  237.     putq(&actuser,user);
  238.     printf("%s: Directory request %02x %d\n",callsign,flags,block_size);
  239.     for ( ; i < lnrkss; i += (4+4)) {
  240.         memcpy(&start,&rkss[i],4);
  241.         memcpy(&end,  &rkss[i+4],4);
  242.         hole = (struct sthole *)getq(&freehole);
  243.     if (hole == NULL)
  244.         break;
  245.         hole->start = start;
  246.         hole->end   = end;
  247.         putq(&user->hole,hole);
  248.     printf("        %lu,%lu\n",start,end);
  249.     }
  250.     return(0);        /* OK */
  251. }
  252.  
  253. /*
  254.  * < pfhstat > PFH stat
  255.  */
  256. int pfhstat(name,pfh)
  257. char name[];
  258. struct stpfh *pfh;
  259. {
  260.     FILE *fp;
  261.     int c,i,s,length;
  262.     char data[256];
  263.     u_int id;
  264.  
  265.     s = 0;
  266.  
  267.     if ((fp = fopen(name,"rb")) == NULL) {
  268.         return(-1);
  269.     }
  270.     c = fgetc(fp);
  271.     s++;
  272.     id = (c<<8);
  273.     c = fgetc(fp);
  274.     s++;
  275.     id |= c;
  276.     if (id != 0xaa55) {    /* PFH check ? */
  277.         fclose(fp);
  278.     return(-1);
  279.     }
  280.     for (;;) {
  281.         c = fgetc(fp);
  282.     if (c == EOF)
  283.         break;
  284.     id = c;
  285.     c = fgetc(fp);
  286.     id |= (c<<8);
  287.     c = fgetc(fp);
  288.     length = c;
  289.     s += 3;
  290.     if (id == 0 && length == 0)    /* termination ? */
  291.         break;
  292.     for (i = 0; i < length; i++) {
  293.         data[i] = fgetc(fp);
  294.         s++;
  295.     }
  296.     switch(id) {
  297.         case 0x04:
  298.             memcpy(&pfh->file_size,data,4);
  299.         break;
  300.         case 0x08:
  301.             pfh->file_type = data[0];
  302.         break;
  303.         case 0x0b:
  304.             memcpy(&pfh->body_offset,data,2);
  305.         break;
  306.         default:
  307.             break;
  308.     }
  309.     }
  310.     fclose(fp);
  311.     pfh->pfh_size = s;
  312.     return(0);
  313. }
  314.  
  315. /* pbdir.c */
  316.